package com.android.lovely.ext

import android.graphics.Typeface
import android.text.SpannableStringBuilder
import android.text.style.AbsoluteSizeSpan
import android.text.style.ForegroundColorSpan
import android.text.style.StyleSpan
import androidx.core.text.buildSpannedString
import androidx.core.text.inSpans
import com.android.lovely.data.DialogueStyle
import com.android.lovely.manager.KVStore
import com.kotlin.extensions.dimen.Dimension.sp

/**
 * 消息处理工具类 - 负责管理消息样式和格式化
 *
 * 提供了格式化文本消息、应用样式的功能
 * 
 * @author why
 */
object MessageHelper {
    
    /**
     * 获取角色对话样式
     * @return DialogueStyle 角色的对话样式
     */
    val roleStyle: DialogueStyle 
        get() = KVStore.talkStyle.role

    /**
     * 获取用户对话样式
     * @return DialogueStyle 用户的对话样式
     */
    val userStyle: DialogueStyle 
        get() = KVStore.talkStyle.user
    
    /**
     * 将字符串应用对话样式，支持特殊格式标记
     * - 引号包裹内容: "示例" 将使用对话颜色
     * - 星号包裹内容: **示例** 将使用描述颜色和加粗
     * - 反引号包裹内容: ```示例``` 将使用描述颜色
     * - 普通文本: 将使用描述颜色
     *
     * @param style 要应用的对话样式
     * @return CharSequence 格式化后的富文本
     */
    fun String.applyMessageWithStyle(style: DialogueStyle,  isPreview: Boolean = false): CharSequence {
        // 匹配不同的文本格式: 引号包裹、**包裹**、```包裹```、普通文本
        val pattern =
//            Regex("[“”\"„“]([^“”\"„“]+)[“”\"„“]|\\*\\*([^*]+)\\*\\*|```([^`]+)```|([^“”\"„“*`]+)")
            Regex(
                "[“”\"„“]([^“”\"„“]+)[“”\"„“]" +    //引号内容
                        "|\\*([^*]+)\\*" +  //单星号内容
                        "|\\*\\*([^*]+)\\*\\*" +    //双星号内容
                        "|```([^`]+)```" +  //三个反引号包裹的内容
                        "|([^“”\"„“*`]+)"   //匹配普通文本
            )
        val matches = pattern.findAll(this)
        
        return buildSpannedString {
            runCatching {
                for (match in matches) {
                    when {
                        match.groups[1] != null -> {
                            // 引号包裹的内容
                            val matchText = match.groups[1]?.value ?: ""
                            appendStyledSpan(
                                text = "\"$matchText\"",
                                color = style.dialogueColor,
                                italic = style.dialogueItalic,
                                bold = false,
                                fontSize = style.fontSize
                            )
                        }
                        match.groups[2] != null -> {
                            // 单星号内容
                            val matchText = match.groups[2]?.value ?: ""
                            appendStyledSpan(
                                text = if(isPreview) "*$matchText*" else matchText,
                                color = style.descColor,
                                italic = style.descItalic,
                                bold = true,
                                fontSize = style.fontSize
                            )
                        }
                        match.groups[3] != null -> {
                            // 双星号内容
                            val matchText = match.groups[3]?.value ?: ""
                            appendStyledSpan(
                                text = matchText,
                                color = style.otherColor,
                                italic = style.otherItalic,
                                bold = true,
                                fontSize = style.fontSize
                            )
                        }
                        match.groups[4] != null -> {
                            // 三个反引号包裹的内容
                            val matchText = match.groups[4]?.value ?: ""
                            appendStyledSpan(
                                text = matchText, 
                                color = style.otherColor,
                                italic = style.otherItalic,
                                bold = false,
                                fontSize = style.fontSize
                            )
                        }
                        match.groups[5] != null -> {
                            // 普通文本
                            val matchText = match.groups[5]?.value ?: ""
                            appendStyledSpan(
                                text = matchText, 
                                color = style.otherColor,
                                italic = style.otherItalic,
                                bold = false,
                                fontSize = style.fontSize
                            )
                        }
                    }
                }
            }
        }
    }

    /**
     * 向 SpannableStringBuilder 添加带样式的文本
     *
     * @param text 要添加的文本
     * @param color 文本颜色
     * @param italic 是否斜体
     * @param bold 是否加粗
     * @param fontSize 字体大小
     */
    private fun SpannableStringBuilder.appendStyledSpan(
        text: String,
        color: Int,
        italic: Boolean,
        bold: Boolean,
        fontSize: Int
    ) {
        val typeface = when {
            italic && bold -> Typeface.BOLD_ITALIC
            italic -> Typeface.ITALIC
            bold -> Typeface.BOLD
            else -> Typeface.NORMAL
        }
        
        inSpans(
            ForegroundColorSpan(color),
            StyleSpan(typeface),
            AbsoluteSizeSpan(fontSize.sp, false)
        ) { 
            append(text) 
        }
    }
}

/**
 * 颜色处理工具类 - 负责颜色转换和处理
 */
object ColorUtils {
    /**
     * 根据透明度百分比计算新的颜色值
     *
     * @param alphaPercent 透明度百分比，范围 0-100
     * @return Int 应用透明度后的颜色值
     * @throws IllegalArgumentException 如果透明度百分比不在 0-100 范围内
     */
    fun Int.calculateColor(alphaPercent: Int): Int {
        require(alphaPercent in 0..100) { "Alpha percentage must be between 0 and 100" }
        val newAlpha = (alphaPercent * 255 / 100).coerceIn(0, 255)
        // 清除原来的 Alpha 部分，并设置新的 Alpha 值
        return (this and 0x00FFFFFF) or (newAlpha shl 24)
    }
}